Técnicas de Refactorización en Python: Una Guía Completa para la Mejora de la Calidad del Código

En el panorama en constante evolución del desarrollo de software, mantener un código limpio, eficiente y comprensible es primordial. Python, conocido por su legibilidad, aún puede ser presa de malos olores de código y deuda técnica si no se gestiona cuidadosamente. La refactorización es el proceso de reestructurar el código informático existente, cambiando la factorización, sin cambiar su comportamiento externo. En esencia, es limpiar su código sin romperlo. Esta guía explora varias técnicas de refactorización de Python, proporcionando ejemplos prácticos y mejores prácticas para elevar la calidad de su código.

¿Por qué refactorizar el código Python?

La refactorización ofrece numerosos beneficios, que incluyen:

• Legibilidad mejorada: Hace que el código sea más fácil de entender y mantener.
• Complejidad reducida: Simplifica la lógica compleja, reduciendo la probabilidad de errores.
• Mantenibilidad mejorada: Facilita la modificación y extensión del código.
• Rendimiento incrementado: Puede optimizar el código para una mejor velocidad de ejecución.
• Menos deuda técnica: Evita la acumulación de código que es difícil de mantener o extender.
• Mejor diseño: Conduce a una arquitectura de código más robusta y flexible.

Ignorar la refactorización puede llevar a un código que es difícil de entender, modificar y probar. Esto puede aumentar significativamente el tiempo de desarrollo y el riesgo de introducir errores.

¿Cuándo refactorizar?

Saber cuándo refactorizar es crucial. Aquí hay algunos escenarios comunes:

• Antes de agregar nuevas funciones: Refactorizar el código existente puede facilitar la integración de nueva funcionalidad.
• Después de corregir un error: Refactorizar el código circundante puede evitar que se repitan errores similares.
• Durante las revisiones de código: Identificar áreas que se pueden mejorar y refactorizarlas.
• Cuando se encuentra con "malos olores de código": Los malos olores de código son indicadores de posibles problemas en su código.
• Refactorización programada regularmente: Incorpore la refactorización en su proceso de desarrollo como una actividad regular.

Identificación de malos olores de código

Los malos olores de código son indicaciones superficiales que generalmente corresponden a un problema más profundo en el sistema. No siempre indican un problema, pero a menudo justifican una investigación adicional.

Malos olores de código comunes en Python:

• Código duplicado: Código idéntico o muy similar que aparece en múltiples lugares.
• Método/Función larga: Métodos o funciones que son excesivamente largos y complejos.
• Clase grande: Clases que tienen demasiadas responsabilidades.
• Lista de parámetros larga: Métodos o funciones con demasiados parámetros.
• Agrupaciones de datos: Grupos de datos que aparecen con frecuencia juntos.
• Obsesión primitiva: Usar tipos de datos primitivos en lugar de crear objetos.
• Sentencias switch: Largas cadenas de sentencias if/elif/else o sentencias switch.
• Cirugía de escopeta: Realizar un solo cambio requiere realizar muchos cambios pequeños en diferentes clases.
• Cambio divergente: Una clase se cambia comúnmente de diferentes maneras por diferentes razones.
• Envidia de funciones: Un método accede a los datos de otro objeto más que a sus propios datos.
• Cadenas de mensajes: Un cliente le pide a un objeto que solicite a otro objeto que solicite a otro objeto...

Técnicas de refactorización en Python: Una guía práctica

Esta sección detalla varias técnicas comunes de refactorización en Python con ejemplos prácticos.

1. Extraer método/función

Esta técnica implica tomar un bloque de código dentro de un método o función y moverlo a un nuevo método o función separado. Esto reduce la complejidad del método original y hace que el código extraído sea reutilizable.

Ejemplo:

            
def print_invoice(customer, details):
    print("***********************")
    print(f"Cliente: {customer}")
    print("***********************")

    total_amount = 0
    for order in details["orders"]:
        total_amount += order["amount"]

    print(f"El monto es: {total_amount}")

    if total_amount > 1000:
        print("¡Has ganado un descuento!")

            

              
                Copy
              
            
          

Refactorizado:

            
def print_header(customer):
    print("***********************")
    print(f"Cliente: {customer}")
    print("***********************")


def calculate_total(details):
    total_amount = 0
    for order in details["orders"]:
        total_amount += order["amount"]
    return total_amount


def print_invoice(customer, details):
    print_header(customer)
    total_amount = calculate_total(details)
    print(f"El monto es: {total_amount}")

    if total_amount > 1000:
        print("¡Has ganado un descuento!")

            

              
                Copy
              
            
          

2. Extraer clase

Cuando una clase tiene demasiadas responsabilidades, extraiga algunas de ellas en una nueva clase. Esto promueve el Principio de Responsabilidad Única.

Ejemplo:

            
class Persona:
    def __init__(self, nombre, numero_de_telefono, codigo_area_oficina, numero_oficina):
        self.nombre = nombre
        self.numero_de_telefono = numero_de_telefono
        self.codigo_area_oficina = codigo_area_oficina
        self.numero_oficina = numero_oficina

    def get_nombre(self):
        return self.nombre

    def get_numero_de_telefono(self):
        return f"({self.codigo_area_oficina}) {self.numero_oficina}"

            

              
                Copy
              
            
          

Refactorizado:

            
class NumeroTelefono:
    def __init__(self, codigo_area, numero):
        self.codigo_area = codigo_area
        self.numero = numero

    def get_numero_de_telefono(self):
        return f"({self.codigo_area}) {self.numero}"


class Persona:
    def __init__(self, nombre, numero_telefono):
        self.nombre = nombre
        self.numero_telefono = numero_telefono

    def get_nombre(self):
        return self.nombre

            

              
                Copy
              
            
          

3. Función/método en línea

Esto es lo opuesto a Extraer Método. Si el cuerpo de un método es tan claro como su nombre, puede poner el método en línea reemplazando las llamadas al método con el contenido del método.

Ejemplo:

            
def get_rating(driver):
    return more_than_five_late_deliveries(driver) ? 2 : 1


def more_than_five_late_deliveries(driver):
    return driver.number_of_late_deliveries > 5

            

              
                Copy
              
            
          

Refactorizado:

            
def get_rating(driver):
    return driver.number_of_late_deliveries > 5 ? 2 : 1

            

              
                Copy
              
            
          

4. Reemplazar temporal con consulta

En lugar de usar una variable temporal para guardar el resultado de una expresión, extraiga la expresión en un método. Esto evita la duplicación de código y promueve una mejor legibilidad.

Ejemplo:

            
def get_price(order):
    base_price = order.quantity * order.item_price
    discount_factor = 0.98 if base_price > 1000 else 0.95
    return base_price * discount_factor

            

              
                Copy
              
            
          

Refactorizado:

            
def get_price(order):
    return base_price(order) * discount_factor(order)


def base_price(order):
    return order.quantity * order.item_price


def discount_factor(order):
    return 0.98 if base_price(order) > 1000 else 0.95

            

              
                Copy
              
            
          

5. Introducir objeto de parámetro

Si tiene una larga lista de parámetros que aparecen con frecuencia juntos, considere crear un objeto de parámetro para encapsularlos. Esto reduce la longitud de la lista de parámetros y mejora la organización del código.

Ejemplo:

            
def calculate_total(ancho, alto, profundidad, peso, metodo_envio):
    # Lógica de cálculo
    pass

            

              
                Copy
              
            
          

Refactorizado:

            
class DetallesEnvio:
    def __init__(self, ancho, alto, profundidad, peso, metodo_envio):
        self.ancho = ancho
        self.alto = alto
        self.profundidad = profundidad
        self.peso = peso
        self.metodo_envio = metodo_envio


def calculate_total(detalles_envio):
    # Lógica de cálculo usando atributos de detalles_envio
    pass

            

              
                Copy
              
            
          

6. Reemplazar condicional con polimorfismo

Cuando tiene una declaración condicional compleja que elige el comportamiento en función del tipo de un objeto, considere usar el polimorfismo para delegar el comportamiento a las subclases. Esto promueve una mejor organización del código y facilita la adición de nuevos tipos.

Ejemplo:

            
def calculate_bonus(employee):
    if employee.employee_type == "SALES":
        return employee.sales * 0.1
    elif employee.employee_type == "ENGINEER":
        return employee.projects_completed * 100
    elif employee.employee_type == "MANAGER":
        return 1000
    else:
        return 0

            

              
                Copy
              
            
          

Refactorizado:

            
class Empleado:
    def calculate_bonus(self):
        return 0


class EmpleadoVentas(Empleado):
    def __init__(self, ventas):
        self.ventas = ventas

    def calculate_bonus(self):
        return self.ventas * 0.1


class EmpleadoIngeniero(Empleado):
    def __init__(self, proyectos_completados):
        self.proyectos_completados = proyectos_completados

    def calculate_bonus(self):
        return self.projects_completed * 100


class EmpleadoGerente(Empleado):
    def calculate_bonus(self):
        return 1000

            

              
                Copy
              
            
          

7. Descomponer condicional

Similar a Extraer Método, esto implica dividir una declaración condicional compleja en métodos más pequeños y manejables. Esto mejora la legibilidad y facilita la comprensión de la lógica del condicional.

Ejemplo:

            
if (platform.upper().index("MAC") > -1) and (browser.upper().index("IE") > -1) and was_initialized() and resize > MAX_RESIZE:
    # Hacer algo
    pass

            

              
                Copy
              
            
          

Refactorizado:

            
def is_mac_os():
    return platform.upper().index("MAC") > -1


def is_ie_browser():
    return browser.upper().index("IE") > -1


if is_mac_os() and is_ie_browser() and was_initialized() and resize > MAX_RESIZE:
    # Hacer algo
    pass

            

              
                Copy
              
            
          

8. Reemplazar número mágico con constante simbólica

Reemplace los valores numéricos literales con constantes con nombre. Esto mejora la legibilidad y facilita el cambio de los valores más adelante. Esto se aplica también a otros valores literales como cadenas. Considere los códigos de moneda (por ejemplo, 'USD', 'EUR', 'JPY') o códigos de estado (por ejemplo, 'ACTIVO', 'INACTIVO', 'PENDIENTE') desde una perspectiva global.

Ejemplo:

            
def calculate_area(radius):
    return 3.14159 * radius * radius

            

              
                Copy
              
            
          

Refactorizado:

            
PI = 3.14159

def calculate_area(radius):
    return PI * radius * radius

            

              
                Copy
              
            
          

9. Eliminar intermediario

Si una clase simplemente está delegando llamadas a otra clase, considere eliminar el intermediario y permitir que el cliente acceda directamente a la clase de destino.

Ejemplo:

            
class Persona:
    def __init__(self, departamento):
        self.departamento = departamento

    def get_manager(self):
        return self.department.get_manager()


class Departamento:
    def __init__(self, gerente):
        self.gerente = gerente

    def get_manager(self):
        return self.gerente

            

              
                Copy
              
            
          

Refactorizado:

            
class Persona:
    def __init__(self, gerente):
        self.gerente = gerente

    def get_manager(self):
        return self.gerente

            

              
                Copy
              
            
          

10. Introducir aserción

Use aserciones para documentar suposiciones sobre el estado del programa. Esto puede ayudar a detectar errores temprano y hacer que el código sea más robusto.

Ejemplo:

            
def calculate_discount(price, discount_percentage):
    if discount_percentage < 0 or discount_percentage > 100:
        raise ValueError("El porcentaje de descuento debe estar entre 0 y 100")
    return price * (1 - discount_percentage / 100)

            

              
                Copy
              
            
          

Refactorizado:

            
def calculate_discount(price, discount_percentage):
    assert 0 <= discount_percentage <= 100, "El porcentaje de descuento debe estar entre 0 y 100"
    return price * (1 - discount_percentage / 100)

            

              
                Copy
              
            
          

Herramientas para la refactorización en Python

Varias herramientas pueden ayudar con la refactorización en Python:

• Rope: Una biblioteca de refactorización para Python.
• PyCharm: Un popular IDE de Python con soporte de refactorización integrado.
• VS Code con extensión de Python: Un editor versátil con capacidades de refactorización a través de extensiones.
• Sourcery: Una herramienta de refactorización automatizada.
• Bowler: Una herramienta de refactorización de Facebook para modificaciones de código a gran escala.

Mejores prácticas para la refactorización en Python

• Escribir pruebas unitarias: Asegúrese de que su código esté bien probado antes de refactorizar.
• Refactorizar en pequeños pasos: Realice cambios pequeños e incrementales para minimizar el riesgo de introducir errores.
• Probar después de cada paso de refactorización: Verifique que sus cambios no hayan roto nada.
• Usar el control de versiones: Confirme sus cambios con frecuencia para revertirlos fácilmente si es necesario.
• Comunicarse con su equipo: Informe a su equipo sobre sus planes de refactorización.
• Concéntrese en la legibilidad: Priorice hacer que su código sea más fácil de entender.
• No refactorice solo por el hecho de hacerlo: Refactorice cuando resuelva un problema específico.
• Automatice la refactorización donde sea posible: Utilice herramientas para automatizar las tareas de refactorización repetitivas.

Consideraciones globales para la refactorización

Al trabajar en proyectos internacionales o para una audiencia global, considere estos factores durante la refactorización:

• Localización (L10n) e Internacionalización (I18n): Asegúrese de que su código admita correctamente diferentes idiomas, monedas y formatos de fecha. Refactorice para aislar la lógica específica de la configuración regional.
• Codificación de caracteres: Use la codificación UTF-8 para admitir una amplia gama de caracteres. Refactorice el código que asume una codificación específica.
• Sensibilidad cultural: Tenga en cuenta las normas culturales y evite el uso de lenguaje o imágenes que puedan ser ofensivos. Revise los literales de cadena y los elementos de la interfaz de usuario durante la refactorización.
• Zonas horarias: Maneje las conversiones de zona horaria correctamente. Refactorice el código que hace suposiciones sobre la zona horaria del usuario. Use bibliotecas como `pytz`.
• Manejo de divisas: Use tipos de datos y bibliotecas apropiadas para manejar valores monetarios. Refactorice el código que realiza conversiones manuales de divisas. Bibliotecas como `babel` son útiles.

Ejemplo: Localización de formatos de fecha

            
import datetime

def format_date(date):
    return date.strftime("%m/%d/%Y")  # Formato de fecha de EE. UU.

            

              
                Copy
              
            
          

Refactorizado:

            
import datetime
import locale


def format_date(date, locale_code):
    locale.setlocale(locale.LC_TIME, locale_code)
    return date.strftime("%x")  # Formato de fecha específico de la configuración regional

# Ejemplo de uso:
# format_date(datetime.date(2024, 1, 1), 'en_US.UTF-8') # Salida: '01/01/2024'
# format_date(datetime.date(2024, 1, 1), 'de_DE.UTF-8') # Salida: '01.01.2024'

            

              
                Copy
              
            
          

Conclusión

La refactorización es una práctica esencial para mantener un código Python de alta calidad. Al identificar y abordar los malos olores de código, aplicar las técnicas de refactorización adecuadas y seguir las mejores prácticas, puede mejorar significativamente la legibilidad, la mantenibilidad y el rendimiento de su código. Recuerde priorizar las pruebas y la comunicación durante todo el proceso de refactorización. Adoptar la refactorización como un proceso continuo conducirá a un flujo de trabajo de desarrollo de software más robusto y sostenible, particularmente cuando se desarrolla para una audiencia global y diversa.